with Interfaces.C; use Interfaces.C;
with SDL_stdinc_h;
with System;
with Interfaces.C.Strings;
limited with SDL_rwops_h;

package SDL_audio_h is


  AUDIO_U8 : constant := 16#0008#;  --  SDL_audio.h:61
  AUDIO_S8 : constant := 16#8008#;  --  SDL_audio.h:62
  AUDIO_U16LSB : constant := 16#0010#;  --  SDL_audio.h:63
  AUDIO_S16LSB : constant := 16#8010#;  --  SDL_audio.h:64
  AUDIO_U16MSB : constant := 16#1010#;  --  SDL_audio.h:65
  AUDIO_S16MSB : constant := 16#9010#;  --  SDL_audio.h:66
  --  unsupported macro: AUDIO_U16 AUDIO_U16LSB
  --  unsupported macro: AUDIO_S16 AUDIO_S16LSB
  --  unsupported macro: AUDIO_U16SYS AUDIO_U16LSB
  --  unsupported macro: AUDIO_S16SYS AUDIO_S16LSB
  --  arg-macro: procedure SDL_LoadWAV (file, spec, audio_buf, audio_len)
  --    SDL_LoadWAV_RW(SDL_RWFromFile(file, "rb"),1, spec,audio_buf,audio_len)

  SDL_MIX_MAXVOLUME : constant := 128;  --  SDL_audio.h:229


  --

  -- Access to the raw audio mixing buffer for the SDL library
  -- Set up for C function definitions, even when using C++
  -- The calculated values in this structure are calculated by SDL_OpenAudio()
  -- DSP frequency -- samples per second
   type SDL_AudioSpec is record
      freq : aliased int;  -- SDL_audio.h:43:6
      format : aliased SDL_stdinc_h.Uint16;  -- SDL_audio.h:44:9
      channels : aliased SDL_stdinc_h.Uint8;  -- SDL_audio.h:45:9
      silence : aliased SDL_stdinc_h.Uint8;  -- SDL_audio.h:46:9
      samples : aliased SDL_stdinc_h.Uint16;  -- SDL_audio.h:47:9
      padding : aliased SDL_stdinc_h.Uint16;  -- SDL_audio.h:48:9
      size : aliased SDL_stdinc_h.Uint32;  -- SDL_audio.h:49:9
      callback : access procedure
           (arg1 : System.Address;
            arg2 : access SDL_stdinc_h.Uint8;
            arg3 : int);  -- SDL_audio.h:56:65
      userdata : System.Address;  -- SDL_audio.h:57:9
   end record;
   pragma Convention (C, SDL_AudioSpec);  -- SDL_audio.h:42:30

  -- Audio data format
  -- Number of channels: 1 mono, 2 stereo
  -- Audio buffer silence value (calculated)
  -- Audio buffer size in samples (power of 2)
  -- Necessary for some compile environments
  -- Audio buffer size in bytes (calculated)
  -- This function is called when the audio device needs more data.
  --	   'stream' is a pointer to the audio data buffer
  --	   'len' is the length of that buffer in bytes.
  --	   Once the callback returns, the buffer will no longer be valid.
  --	   Stereo samples are stored in a LRLRLR ordering.
  --

  -- Audio format flags (defaults to LSB byte order)
  -- Native audio byte ordering
  -- A structure to hold a set of audio conversion filters and buffers
  -- Set to 1 if conversion possible

   type Sdl_Audiocvt;
   type SDL_AudioCVT_filters_array is array (0 .. 9) of access procedure (arg1 : access SDL_AudioCVT; arg2 : SDL_stdinc_h.Uint16);

   type SDL_AudioCVT is record
      needed : aliased int;  -- SDL_audio.h:82:6
      src_format : aliased SDL_stdinc_h.Uint16;  -- SDL_audio.h:83:9
      dst_format : aliased SDL_stdinc_h.Uint16;  -- SDL_audio.h:84:9
      rate_incr : aliased double;  -- SDL_audio.h:85:9
      buf : access SDL_stdinc_h.Uint8;  -- SDL_audio.h:86:9
      len : aliased int;  -- SDL_audio.h:87:9
      len_cvt : aliased int;  -- SDL_audio.h:88:9
      len_mult : aliased int;  -- SDL_audio.h:89:9
      len_ratio : aliased double;  -- SDL_audio.h:90:9
      filters : aliased SDL_AudioCVT_filters_array;  -- SDL_audio.h:91:69
      filter_index : aliased int;  -- SDL_audio.h:92:6
   end record;
   pragma Convention (C, SDL_AudioCVT);  -- SDL_audio.h:81:29



  -- Source audio format
  -- Target audio format
  -- Rate conversion increment
  -- Buffer to hold entire audio data
  -- Length of original audio buffer
  -- Length of converted audio buffer
  -- buffer must be len*len_mult big
  -- Given len, final size is len*len_ratio
  -- Current audio conversion function
  -- Function prototypes
  -- These functions are used internally, and should not be used unless you
  -- * have a specific need to specify the audio driver you want to use.
  -- * You should normally use SDL_Init() or SDL_InitSubSystem().
  --

   function SDL_AudioInit (driver_name : Interfaces.C.Strings.chars_ptr) return int;  -- SDL_audio.h:102:66
   pragma Import (C, SDL_AudioInit, "SDL_AudioInit");

   procedure SDL_AudioQuit;  -- SDL_audio.h:103:48
   pragma Import (C, SDL_AudioQuit, "SDL_AudioQuit");

  -- This function fills the given character buffer with the name of the
  -- * current audio driver, and returns a pointer to it if the audio driver has
  -- * been initialized.  It returns NULL if no driver has been initialized.
  --

   function SDL_AudioDriverName (namebuf : Interfaces.C.Strings.chars_ptr; maxlen : int) return Interfaces.C.Strings.chars_ptr;  -- SDL_audio.h:109:77
   pragma Import (C, SDL_AudioDriverName, "SDL_AudioDriverName");

  -- * This function opens the audio device with the desired parameters, and
  -- * returns 0 if successful, placing the actual hardware parameters in the
  -- * structure pointed to by 'obtained'.  If 'obtained' is NULL, the audio
  -- * data passed to the callback function will be guaranteed to be in the
  -- * requested format, and will be automatically converted to the hardware
  -- * audio format if necessary.  This function returns -1 if it failed
  -- * to open the audio device, or couldn't set up the audio thread.
  -- *
  -- * When filling in the desired audio spec structure,
  -- *  'desired->freq' should be the desired audio frequency in samples-per-second.
  -- *  'desired->format' should be the desired audio format.
  -- *  'desired->samples' is the desired size of the audio buffer, in samples.
  -- *     This number should be a power of two, and may be adjusted by the audio
  -- *     driver to a value more suitable for the hardware.  Good values seem to
  -- *     range between 512 and 8096 inclusive, depending on the application and
  -- *     CPU speed.  Smaller values yield faster response time, but can lead
  -- *     to underflow if the application is doing heavy processing and cannot
  -- *     fill the audio buffer in time.  A stereo sample consists of both right
  -- *     and left channels in LR ordering.
  -- *     Note that the number of samples is directly related to time by the
  -- *     following formula:  ms = (samples*1000)/freq
  -- *  'desired->size' is the size in bytes of the audio buffer, and is
  -- *     calculated by SDL_OpenAudio().
  -- *  'desired->silence' is the value used to set the buffer to silence,
  -- *     and is calculated by SDL_OpenAudio().
  -- *  'desired->callback' should be set to a function that will be called
  -- *     when the audio device is ready for more data.  It is passed a pointer
  -- *     to the audio buffer, and the length in bytes of the audio buffer.
  -- *     This function usually runs in a separate thread, and so you should
  -- *     protect data structures that it accesses by calling SDL_LockAudio()
  -- *     and SDL_UnlockAudio() in your code.
  -- *  'desired->userdata' is passed as the first parameter to your callback
  -- *     function.
  -- *
  -- * The audio device starts out playing silence when it's opened, and should
  -- * be enabled for playing by calling SDL_PauseAudio(0) when you are ready
  -- * for your audio callback function to be called.  Since the audio driver
  -- * may modify the requested size of the audio buffer, you should allocate
  -- * any local mixing buffers after you open the audio device.
  --

   function SDL_OpenAudio (desired : access SDL_AudioSpec; obtained : access SDL_AudioSpec) return int;  -- SDL_audio.h:152:90
   pragma Import (C, SDL_OpenAudio, "SDL_OpenAudio");

  -- * Get the current audio state:
  --

   subtype SDL_audiostatus is unsigned;
   SDL_AUDIO_STOPPED : constant SDL_audiostatus := 0;
   SDL_AUDIO_PLAYING : constant SDL_audiostatus := 1;
   SDL_AUDIO_PAUSED : constant SDL_audiostatus := 2;  -- SDL_audio.h:161:3

   function SDL_GetAudioStatus return SDL_audiostatus;  -- SDL_audio.h:162:64
   pragma Import (C, SDL_GetAudioStatus, "SDL_GetAudioStatus");

  -- * This function pauses and unpauses the audio callback processing.
  -- * It should be called with a parameter of 0 after opening the audio
  -- * device to start playing sound.  This is so you can safely initialize
  -- * data for your callback function after opening the audio device.
  -- * Silence will be written to the audio device during the pause.
  --

   procedure SDL_PauseAudio (pause_on : int);  -- SDL_audio.h:171:57
   pragma Import (C, SDL_PauseAudio, "SDL_PauseAudio");

  -- * This function loads a WAVE from the data source, automatically freeing
  -- * that source if 'freesrc' is non-zero.  For example, to load a WAVE file,
  -- * you could do:
  -- *	SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...);
  -- *
  -- * If this function succeeds, it returns the given SDL_AudioSpec,
  -- * filled with the audio data format of the wave data, and sets
  -- * 'audio_buf' to a malloc()'d buffer containing the audio data,
  -- * and sets 'audio_len' to the length of that audio buffer, in bytes.
  -- * You need to free the audio buffer with SDL_FreeWAV() when you are
  -- * done with it.
  -- *
  -- * This function returns NULL and sets the SDL error message if the
  -- * wave file cannot be opened, uses an unknown data format, or is
  -- * corrupt.  Currently raw and MS-ADPCM WAVE files are supported.
  --

   function SDL_LoadWAV_RW
     (src : access SDL_rwops_h.SDL_RWops;
      freesrc : int;
      spec : access SDL_AudioSpec;
      audio_buf : System.Address;
      audio_len : access SDL_stdinc_h.Uint32) return access SDL_AudioSpec;  -- SDL_audio.h:190:142
   pragma Import (C, SDL_LoadWAV_RW, "SDL_LoadWAV_RW");

  -- Compatibility convenience function -- loads a WAV from a file
  -- * This function frees data previously allocated with SDL_LoadWAV_RW()
  --

   procedure SDL_FreeWAV (audio_buf : access SDL_stdinc_h.Uint8);  -- SDL_audio.h:199:58
   pragma Import (C, SDL_FreeWAV, "SDL_FreeWAV");

  -- * This function takes a source format and rate and a destination format
  -- * and rate, and initializes the 'cvt' structure with information needed
  -- * by SDL_ConvertAudio() to convert a buffer of audio data from one format
  -- * to the other.
  -- * This function returns 0, or -1 if there was an error.
  --

   function SDL_BuildAudioCVT
     (cvt : access SDL_AudioCVT;
      src_format : SDL_stdinc_h.Uint16;
      src_channels : SDL_stdinc_h.Uint8;
      src_rate : int;
      dst_format : SDL_stdinc_h.Uint16;
      dst_channels : SDL_stdinc_h.Uint8;
      dst_rate : int) return int;  -- SDL_audio.h:210:54
   pragma Import (C, SDL_BuildAudioCVT, "SDL_BuildAudioCVT");

  -- Once you have initialized the 'cvt' structure using SDL_BuildAudioCVT(),
  -- * created an audio buffer cvt->buf, and filled it with cvt->len bytes of
  -- * audio data in the source format, this function will convert it in-place
  -- * to the desired format.
  -- * The data conversion may expand the size of the audio data, so the buffer
  -- * cvt->buf should be allocated after the cvt structure is initialized by
  -- * SDL_BuildAudioCVT(), and should be cvt->len*cvt->len_mult bytes long.
  --

   function SDL_ConvertAudio (cvt : access SDL_AudioCVT) return int;  -- SDL_audio.h:220:63
   pragma Import (C, SDL_ConvertAudio, "SDL_ConvertAudio");

  -- * This takes two audio buffers of the playing audio format and mixes
  -- * them, performing addition, volume adjustment, and overflow clipping.
  -- * The volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME
  -- * for full audio volume.  Note this does not change hardware volume.
  -- * This is provided for convenience -- you can mix your own audio data.
  --

   procedure SDL_MixAudio
     (dst : access SDL_stdinc_h.Uint8;
      src : access SDL_stdinc_h.Uint8;
      len : SDL_stdinc_h.Uint32;
      volume : int);  -- SDL_audio.h:230:95
   pragma Import (C, SDL_MixAudio, "SDL_MixAudio");

  -- * The lock manipulated by these functions protects the callback function.
  -- * During a LockAudio/UnlockAudio pair, you can be guaranteed that the
  -- * callback function is not running.  Do not call these from the callback
  -- * function or you will cause deadlock.
  --

   procedure SDL_LockAudio;  -- SDL_audio.h:238:48
   pragma Import (C, SDL_LockAudio, "SDL_LockAudio");

   procedure SDL_UnlockAudio;  -- SDL_audio.h:239:50
   pragma Import (C, SDL_UnlockAudio, "SDL_UnlockAudio");

  -- * This function shuts down audio processing and closes the audio device.
  --

   procedure SDL_CloseAudio;  -- SDL_audio.h:244:49
   pragma Import (C, SDL_CloseAudio, "SDL_CloseAudio");

  -- Ends C function definitions when using C++
end SDL_audio_h;
